class Promise {

	constructor(handlerFn){
		this.status = 'pending' // 定义状态
		this.value = undefined // 当前promise的值
		this.fulFilledList = []
		this.rejectedList = []

		// 每当实例化Promise时，需要立即执行的函数handlerFn，并接受两个函数参数 
		handlerFn(this.triggerResolve.bind(this), this.triggerRejected.bind(this))
	}

	// 执行 resolve() 方法后，改变promise的状态，变为 resolve,将then中的onFulfilled注册进去，从而执行后续的操作
	triggerResolve(val){
		// 在下一个事件循环的过程
		setTimeout(() => {
			// 判断当前的状态, 一定得是 pending 的状态
			if (this.status !== 'pending') return

			// 判断传入的参数是不是一个 promsie
			if (val instanceof Promise) {
				val.then(value => {}, err => {})
			} else { // resolve 方法传入的是一个普通纸值
				this.status = 'fulfilled'
				this.value = val
				this.triggerFulfilled() // 将已完成状态的回调函数执行
			}
		})
	}

	// 改变 promise 的状态，变为 reject,
	triggerRejected(){

	}

	triggerFulfilled(val) {
		this.fulFilledList.forEach(item => item())
		this.fulFilledList = []
	}

	// 执行完then方法之后，才能直到resolve这个回调函数需要执行哪些东西
	then(onFulfilled, onRejected){
		const { value, status } = this
		return new Promise((onNextFulfilled, onNextRejected) => {
			// 合并类型判断，链式调用的作用
			function onfinalFulfilled(val) {
				if (typeof onFulfilled !== 'function') {
					onfinalFulfilled(val)
				} else {
					const res = onFulfilled(val)
					if (res instalceof Promise) {
						res.then(onNextFulfilled, onNextRejected)
					} else {
						onNextFulfilled(res)
					}
				}
			}

			// 判断已拒绝状态时，实例对象then的连续调用
			function onFinalRejected(error) {
				if (typeof onRejected !== 'pending') {
					onNextRejected(error)
				}

			}
			switch(status) {
				case 'pending': { // 这里记录所有的回调函数，在下一个事件循环中调用
					this.fulFilledList.push(onfinalFulfilled)
					this.rejectedList.push(onRejected)
					break
				}
			}
		})
	}
	catch(){}

	// Promise的静态方法，只有类能够调用 Promise.resolve()
	static resolve(value){
		// 判断传入的参数类型
		if (value instanceof Promise) return
		return new Promise(resolve => resolve(value))
	}

	static reject(){

	}

	static all(){

	}

	static race(){

	}
}

const promise1 = new Promise(function(resolve, reject){
	
	// 这里是个异步的过程，这里需要注册then函数的回调函数，如果是同步过程，则不知道需要执行什么回调函数
	// 执行 resolve 方法的过程中，是一个异步的过程，在这个异步过程中
	/*
		执行 resolve 方法时，将 promise 的状态变为 已完成，但是将 promise 的状态变为已完成是一个异步的过程，
		这里执行resolve并不能立即改变promise的状态，需要在下一个事件循环的过程中，改变promised的状态，
		同事注入 改变状态时的回调函数，也就是 then 中的回调函数
	*/
	resolve('hello world')
})

promise1.then(function(){ console.log('111') })